package ciyuan.Item;


import ciyuan.Block.BlockRegistryManager;
import ciyuan.Item.Armor.ModArmorMaterial;
import ciyuan.Item.Component.*;
import ciyuan.Item.Food.*;
import ciyuan.Item.Material.*;
import ciyuan.Item.Seed.Cabbageseed;
import ciyuan.Item.Seed.CornSeed;
import ciyuan.Item.Seed.PeanutSeed;
import ciyuan.Item.Seed.Scallionseed;
import ciyuan.Item.SkillBook.*;
import ciyuan.Item.Tools.*;
import ciyuan.Item.Water.Kettle;
import ciyuan.Item.Water.LeatherKettle;
import ciyuan.Item.Weapon.*;
import ciyuan.MainClass;
import net.minecraft.inventory.EquipmentSlotType;
import net.minecraft.item.ArmorItem;
import net.minecraft.item.BlockItem;
import net.minecraft.item.Item;
import net.minecraftforge.fml.RegistryObject;
import net.minecraftforge.registries.DeferredRegister;
import net.minecraftforge.registries.ForgeRegistries;

import static ciyuan.Item.ItemGroups.*;

/**
 * @author 150149
 */

public class ItemRegisterManager {

    public static final DeferredRegister ITEMS = DeferredRegister.create(ForgeRegistries.ITEMS, MainClass.MODID);
    public static RegistryObject<Item> Kettle = ITEMS.register("kettle", () -> new Kettle());
    public static RegistryObject<Item> Shit = ITEMS.register("shit", () -> new Shit());
    public static RegistryObject<Item> Salt = ITEMS.register("salt", () -> new Salt());
    public static RegistryObject<Item> Oil = ITEMS.register("oil", () -> new Oil());
    public static RegistryObject<Item> Rope = ITEMS.register("rope", () -> new Rope());
    public static RegistryObject<Item> Straw = ITEMS.register("straw", () -> new Straw());
    public static RegistryObject<Item> Rock = ITEMS.register("rock", () -> new Rock());
    public static RegistryObject<Item> WoodAxe0 = ITEMS.register("woodaxe0", () -> new WoodAxe0());
    public static RegistryObject<Item> Tomato = ITEMS.register("tomato", () -> new Tomato());
    public static RegistryObject<Item> LeatherKettle = ITEMS.register("leatherkettle", () -> new LeatherKettle());
    public static RegistryObject<Item> Scallion = ITEMS.register("scallion", () -> new Scallion());
    public static RegistryObject<Item> Pepper = ITEMS.register("pepper", () -> new Pepper());
    public static RegistryObject<Item> Cabbage = ITEMS.register("cabbage", () -> new Cabbage());
    public static RegistryObject<Item> Barley = ITEMS.register("barley", () -> new Barley());
    public static RegistryObject<Item> Test = ITEMS.register("test", () -> new Test());
    public static RegistryObject<Item> Garlic = ITEMS.register("garlic", () -> new BlockItem(BlockRegistryManager.Garlic.get(), new Item.Properties().tab(Food)));
    public static RegistryObject<Item> Flour = ITEMS.register("flour", () -> new Flour());
    public static RegistryObject<Item> Rice = ITEMS.register("rice", () -> new Rice());
    public static RegistryObject<Item> CarvingKnife = ITEMS.register("carvingknife", () -> new CarvingKnife());
    public static RegistryObject<Item> Barleyseed = ITEMS.register("barleyseed", () -> new BlockItem(BlockRegistryManager.Barley.get(), new Item.Properties().tab(Food)));
    public static RegistryObject<Item> Cabbageseed = ITEMS.register("cabbageseed", () -> new Cabbageseed());
    public static RegistryObject<Item> Pepperseed = ITEMS.register("pepperseed", () -> new BlockItem(BlockRegistryManager.Pepper.get(), new Item.Properties().tab(Food)));
    public static RegistryObject<Item> Scallionseed = ITEMS.register("scallionseed", () -> new Scallionseed());
    public static RegistryObject<Item> Tomatoseed = ITEMS.register("tomatoseed", () -> new BlockItem(BlockRegistryManager.Tomato.get(), new Item.Properties().tab(Food)));
    public static RegistryObject<Item> LiteWood = ITEMS.register("litewood", () -> new LiteWood());
    public static RegistryObject<Item> LargeWood = ITEMS.register("largewood", () -> new LargeWood());
    public static RegistryObject<Item> WoodaxePart = ITEMS.register("woodaxepart", () -> new WoodaxePart());
    public static RegistryObject<Item> WoodHoePart = ITEMS.register("woodhoepart", () -> new WoodHoePart());
    public static RegistryObject<Item> WoodShovelPart = ITEMS.register("woodshovelpart", () -> new WoodShovelPart());
    public static RegistryObject<Item> WoodPickaxePart = ITEMS.register("woodpickaxepart", () -> new WoodPickaxePart());
    public static RegistryObject<Item> WoodSwordPart = ITEMS.register("woodswordpart", () -> new WoodSwordPart());
    public static RegistryObject<Item> FlintShovel = ITEMS.register("flintshovel", () -> new FlintShovel());
    public static RegistryObject<Item> FlintAxe = ITEMS.register("flintaxe", () -> new FlintAxe());
    public static RegistryObject<Item> FlintPickAxe = ITEMS.register("flintpickaxe", () -> new FlintPickAxe());
    public static RegistryObject<Item> FlintHoe = ITEMS.register("flinthoe", () -> new FlintHoe());
    public static RegistryObject<Item> WoodHandle = ITEMS.register("woodhandle", () -> new WoodHandle());
    public static RegistryObject<Item> Braised_Chicken = ITEMS.register("braisedchicken", () -> new Braised_Chicken());
    public static RegistryObject<Item> Egg_Rolls = ITEMS.register("eggrolls", () -> new Egg_Rolls());
    public static RegistryObject<Item> Egg_Soup = ITEMS.register("eggsoup", () -> new Egg_Soup());
    public static RegistryObject<Item> Sauteed_Beef = ITEMS.register("sauteedbeef", () -> new Sauteed_Beef());
    public static RegistryObject<Item> SauteedPork = ITEMS.register("sauteedpork", () -> new SauteedPork());
    public static RegistryObject<Item> Soup_Pepper = ITEMS.register("souppepper", () -> new Soup_Pepper());
    public static RegistryObject<Item> GoldRice = ITEMS.register("goldrice", () -> new GoldRice());
    public static RegistryObject<Item> Oats = ITEMS.register("oats", () -> new Oats());
    public static RegistryObject<Item> FishNoodles = ITEMS.register("fishnoodles", () -> new FishNoodles());
    public static RegistryObject<Item> Dumplings = ITEMS.register("dumplings", () -> new Dumplings());
    public static RegistryObject<Item> FishMutton = ITEMS.register("fishmutton", () -> new FishMutton());
    public static RegistryObject<Item> BoiledEgg = ITEMS.register("boiledegg", () -> new BoiledEgg());
    public static RegistryObject<Item> SweetPot = ITEMS.register("sweetpot", () -> new SweetPot());
    public static RegistryObject<Item> Corn = ITEMS.register("corn", () -> new Corn());
    public static RegistryObject<Item> CornSeed = ITEMS.register("cornseed", () -> new CornSeed());
    public static RegistryObject<Item> Peanut = ITEMS.register("peanut", () -> new Peanut());
    public static RegistryObject<Item> PeanutSeed = ITEMS.register("peanutseed", () -> new PeanutSeed());
    public static RegistryObject<Item> Boilchicken = ITEMS.register("boilchicken", () -> new BoilChicken());
    public static RegistryObject<Item> Hanamaki = ITEMS.register("hanamaki", () -> new Hanamaki());
    public static RegistryObject<Item> SteamedBuns = ITEMS.register("steamedbuns", () -> new SteamedBuns());
    public static RegistryObject<Item> FragrantRice = ITEMS.register("fragrantrice", () -> new FragrantRice());
    public static RegistryObject<Item> SpicyPotato = ITEMS.register("spicypotato", () -> new SpicyPotato());
    public static RegistryObject<Item> Silicon = ITEMS.register("silicon", () -> new Silicon());
    public static RegistryObject<Item> Steel = ITEMS.register("steel", () -> new Steel());
    public static RegistryObject<Item> Aluminium = ITEMS.register("aluminium", () -> new Aluminium());
    public static RegistryObject<Item> tin = ITEMS.register("tin", () -> new Tin());
    public static RegistryObject<Item> Copper = ITEMS.register("copper", () -> new Copper());
    public static RegistryObject<Item> Tin_Alloy = ITEMS.register("tin_alloy", () -> new Tin_Alloy());
    public static RegistryObject<Item> stonestick = ITEMS.register("stonestick", () -> new StoneStick());
    public static RegistryObject<Item> stonepot = ITEMS.register("stonepot", () -> new StonePot());
    public static RegistryObject<Item> stonepot1 = ITEMS.register("stonepot1", () -> new StonePot1());
    public static RegistryObject<Item> stonepot2 = ITEMS.register("stonepot2", () -> new StonePot2());
    public static RegistryObject<Item> stonepot3 = ITEMS.register("stonepot3", () -> new StonePot3());
    public static RegistryObject<Item> stonepot4 = ITEMS.register("stonepot4", () -> new StonePot4());
    public static RegistryObject<Item> selector = ITEMS.register("selector", () -> new Selector());
    public static RegistryObject<Item> placer = ITEMS.register("placer", () -> new Placer());
    public static RegistryObject<Item> breaker = ITEMS.register("breaker", () -> new Breaker());
    public static RegistryObject<Item> broken_tin = ITEMS.register("broken_tin", () -> new Broken_Tin());
    public static RegistryObject<Item> broken_aluminium = ITEMS.register("broken_aluminium", () -> new Broken_Aluminium());
    public static RegistryObject<Item> broken_copper = ITEMS.register("broken_copper", () -> new Broken_Copper());
    public static RegistryObject<Item> broken_iron = ITEMS.register("broken_iron", () -> new Broken_Iron());
    public static RegistryObject<Item> broken_gold = ITEMS.register("broken_gold", () -> new Broken_Gold());
    public static RegistryObject<Item> lignite = ITEMS.register("lignite", () -> new Lignite());
    public static RegistryObject<Item> anthracite = ITEMS.register("anthracite", () -> new Anthracite());
    public static RegistryObject<Item> milling = ITEMS.register("milling", () -> new Milling());
    public static RegistryObject<Item> millstone = ITEMS.register("millstone", () -> new Millstone());
    public static RegistryObject<Item> redstoneassembly = ITEMS.register("redstoneassembly", () -> new RedstoneAssembly());
    public static RegistryObject<Item> stoneframe = ITEMS.register("stoneframe", () -> new StoneFrame());
    public static RegistryObject<Item> forgehammer = ITEMS.register("forgehammer", () -> new ForgeHammer());
    public static RegistryObject<Item> ironplate = ITEMS.register("ironplate", () -> new IronPlate());
    public static RegistryObject<Item> steelplate = ITEMS.register("steelplate", () -> new SteelPlate());
    public static RegistryObject<Item> tinAlloyPlate = ITEMS.register("tinalloyplate", () -> new TinAlloyPlate());
    public static RegistryObject<Item> MechanicalFrame = ITEMS.register("mechanicalframe", () -> new MechanicalFrame());
    public static RegistryObject<Item> refractorybricka = ITEMS.register("refractorybricka", () -> new refractorybricka());
    public static RegistryObject<Item> steelsheet = ITEMS.register("steelsheet", () -> new SteelSheet());
    public static RegistryObject<Item> steelgear = ITEMS.register("steelgear", () -> new SteelGear());
    public static RegistryObject<Item> foil = ITEMS.register("foil", () -> new Foil());
    public static RegistryObject<Item> metal_block = ITEMS.register("metalblock", () -> new MetalBlock());
    public static RegistryObject<Item> CircuitBoard = ITEMS.register("circuitboard", () -> new CircuitBoard());
    public static RegistryObject<Item> steelstick = ITEMS.register("steelstick", () -> new SteelStick());
    public static RegistryObject<Item> steelpipe = ITEMS.register("steelpipe", () -> new SteelPipe());
    public static RegistryObject<Item> ironwire = ITEMS.register("ironwire", () -> new IronWire());
    public static RegistryObject<Item> sulphuricacid = ITEMS.register("sulphuricacid", () -> new SulphuricAcid());
    public static RegistryObject<Item> transistor = ITEMS.register("transistor", () -> new Transistor());
    public static RegistryObject<Item> small_magic_crystals = ITEMS.register("small_magic_crystals", () -> new SmallMagicCrystal());
    public static RegistryObject<Item> magic_crystals = ITEMS.register("magic_crystals", () -> new MagicCrystal());
    public static RegistryObject<Item> big_magic_crystals = ITEMS.register("big_magic_crystals", () -> new BigMagicCrystal());
    public static RegistryObject<Item> skill_page = ITEMS.register("skill_page", () -> new SkillPage());

    public static final RegistryObject<Item> PotBlock = ITEMS.register("pot", () -> new BlockItem(BlockRegistryManager.Pot.get(), new Item.Properties().tab(Block)));
    public static final RegistryObject<Item> Mortar = ITEMS.register("mortar1", () -> new BlockItem(BlockRegistryManager.Mortar.get(), new Item.Properties().tab(Block)));
    public static final RegistryObject<Item> SaltOre = ITEMS.register("salt_ore", () -> new BlockItem(BlockRegistryManager.SaltOre.get(), new Item.Properties().tab(Block)));
    public static final RegistryObject<Item> LigniteOre = ITEMS.register("lignite_ore", () -> new BlockItem(BlockRegistryManager.LigniteOre.get(), new Item.Properties().tab(Block)));
    public static final RegistryObject<Item> PyriteOre = ITEMS.register("pyrite_ore", () -> new BlockItem(BlockRegistryManager.PyriteOre.get(), new Item.Properties().tab(Block)));
    public static final RegistryObject<Item> AluminiumOre = ITEMS.register("aluminium_ore", () -> new BlockItem(BlockRegistryManager.AluminiumOre.get(), new Item.Properties().tab(Block)));
    public static final RegistryObject<Item> QuartzOre = ITEMS.register("quartz_ore", () -> new BlockItem(BlockRegistryManager.QuartzOre.get(), new Item.Properties().tab(Block)));
    public static final RegistryObject<Item> CopperOre = ITEMS.register("copper_ore", () -> new BlockItem(BlockRegistryManager.CopperOre.get(), new Item.Properties().tab(Block)));
    public static final RegistryObject<Item> TinOre = ITEMS.register("tin_ore", () -> new BlockItem(BlockRegistryManager.TinOre.get(), new Item.Properties().tab(Block)));
    public static final RegistryObject<Item> AnthraciteOre = ITEMS.register("anthracite_ore", () -> new BlockItem(BlockRegistryManager.AnthraciteOre.get(), new Item.Properties().tab(Block)));
    public static final RegistryObject<Item> SiliconOre = ITEMS.register("silicon_ore", () -> new BlockItem(BlockRegistryManager.SiliconOre.get(), new Item.Properties().tab(Block)));
    public static final RegistryObject<Item> concrete = ITEMS.register("concrete", () -> new BlockItem(BlockRegistryManager.Concrete.get(), new Item.Properties().tab(Block)));
    public static final RegistryObject<Item> stonepipe = ITEMS.register("stonepipe", () -> new BlockItem(BlockRegistryManager.Stonepipe.get(), new Item.Properties().tab(Block)));
    public static final RegistryObject<Item> refractory_brick = ITEMS.register("refractorybrick", () -> new BlockItem(BlockRegistryManager.refractory_brick.get(), new Item.Properties().tab(Block)));
    public static final RegistryObject<Item> gun1 = ITEMS.register("gun1", () -> new BlockItem(BlockRegistryManager.gun1.get(), new Item.Properties().tab(Block)));

    public static final RegistryObject<Item> fsj = ITEMS.register("fsj", () -> new BlockItem(BlockRegistryManager.fsj.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> gl = ITEMS.register("gl", () -> new BlockItem(BlockRegistryManager.gl.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> jsq = ITEMS.register("jsq", () -> new BlockItem(BlockRegistryManager.jsq.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> jygl = ITEMS.register("jygl", () -> new BlockItem(BlockRegistryManager.jygl.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> jyrss = ITEMS.register("jyrss", () -> new BlockItem(BlockRegistryManager.jyrss.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> st = ITEMS.register("st", () -> new BlockItem(BlockRegistryManager.st.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> lyj = ITEMS.register("lyj", () -> new BlockItem(BlockRegistryManager.lyj.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> pljsrl = ITEMS.register("pljsrl", () -> new BlockItem(BlockRegistryManager.pljsrl.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> fkqgj = ITEMS.register("fkqgj", () -> new BlockItem(BlockRegistryManager.fkqgj.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> rmfdj = ITEMS.register("rmfdj", () -> new BlockItem(BlockRegistryManager.rmfdj.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> dlb = ITEMS.register("dlb", () -> new BlockItem(BlockRegistryManager.dlb.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> ddfsj = ITEMS.register("ddfsj", () -> new BlockItem(BlockRegistryManager.ddfsj.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> yyj = ITEMS.register("yyj", () -> new BlockItem(BlockRegistryManager.yyj.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> tcjhc = ITEMS.register("tcjhc", () -> new BlockItem(BlockRegistryManager.tcjhc.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> yjcxj = ITEMS.register("yjcxj", () -> new BlockItem(BlockRegistryManager.yjcxj.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> fyc = ITEMS.register("fyc", () -> new BlockItem(BlockRegistryManager.fyc.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> yyjlq = ITEMS.register("yyjlq", () -> new BlockItem(BlockRegistryManager.yyjlq.get(), new Item.Properties().tab(Machine)));
    public static final RegistryObject<Item> ryfdj = ITEMS.register("ryfdj", () -> new BlockItem(BlockRegistryManager.ryfdj.get(), new Item.Properties().tab(Machine)));

    public static final RegistryObject<Item> jian1 = ITEMS.register("jian1", Impact.MyArrow::new);
    public static final RegistryObject<Item> jian2 = ITEMS.register("jian2", LightMarker.MarkArrow::new);
    public static final RegistryObject<Item> jian3 = ITEMS.register("jian3", BurningFeather.MarkArrow2::new);
    public static final RegistryObject<Item> jian4 = ITEMS.register("jian4", BurningFeather.Arrow3::new);
    public static final RegistryObject<Item> jian5 = ITEMS.register("jian5", Enchanted.MyArrow2::new);
    public static final RegistryObject<Item> jian6 = ITEMS.register("jian6", ForcedOverload.MyArrow3::new);

    public static final RegistryObject<Item> firstbigsword = ITEMS.register("firstbigsword", FirstBigSword::new);
    public static final RegistryObject<Item> firstsword = ITEMS.register("firstsword", FirstSword::new);
    public static final RegistryObject<Item> firststaff = ITEMS.register("firststaff", FirstStaff::new);
    public static final RegistryObject<Item> firstlawbook = ITEMS.register("firstlawbook", FirstLawBook::new);
    public static final RegistryObject<Item> firstbow = ITEMS.register("firstbow", FirstBow::new);
    public static final RegistryObject<Item> firstcrossbow = ITEMS.register("firstcrossbow", FirstCrossBow::new);
    public static final RegistryObject<Item> ironbigsword = ITEMS.register("ironbigsword", IronBigSword::new);
    public static final RegistryObject<Item> ironsword = ITEMS.register("ironsword", IronSword::new);
    public static final RegistryObject<Item> ironstaff = ITEMS.register("ironstaff", IronStaff::new);
    public static final RegistryObject<Item> ironlawbook = ITEMS.register("ironlawbook", IronLawBook::new);
    public static final RegistryObject<Item> ironbow = ITEMS.register("ironbow", IronBow::new);
    public static final RegistryObject<Item> ironcrossbow = ITEMS.register("ironcrossbow", IronCrossBow::new);
    public static final RegistryObject<Item> tinalloybigsword = ITEMS.register("tinalloybigsword", TinAlloyBigSword::new);
    public static final RegistryObject<Item> tinalloysword = ITEMS.register("tinalloysword", TinAlloySword::new);
    public static final RegistryObject<Item> tinalloystaff = ITEMS.register("tinalloystaff", TinAlloyStaff::new);
    public static final RegistryObject<Item> tinalloylawbook = ITEMS.register("tinalloylawbook", TinAlloyLawBook::new);
    public static final RegistryObject<Item> tinalloybow = ITEMS.register("tinalloybow", TinAlloyBow::new);
    public static final RegistryObject<Item> tinalloycrossbow = ITEMS.register("tinalloycrossbow", TinAlloyCrossBow::new);
    public static final RegistryObject<Item> steelbigsword = ITEMS.register("steelbigsword", SteelBigSword::new);
    public static final RegistryObject<Item> steelsword = ITEMS.register("steelsword", SteelSword::new);
    public static final RegistryObject<Item> steelstaff = ITEMS.register("steelstaff", SteelStaff::new);
    public static final RegistryObject<Item> steellawbook = ITEMS.register("steellawbook", SteelLawBook::new);
    public static final RegistryObject<Item> steelbow = ITEMS.register("steelbow", SteelBow::new);
    public static final RegistryObject<Item> steelcrossbow = ITEMS.register("steelcrossbow", SteelCrossBow::new);

    public static final RegistryObject<Item> xinshouHelmet = ITEMS.register("xinshou_helmet", () -> new ArmorItem(ModArmorMaterial.XINSHOU, EquipmentSlotType.HEAD, (new Item.Properties()).tab(Armor)));
    public static final RegistryObject<Item> xinshouChestplate = ITEMS.register("xinshou_chestplate", () -> new ArmorItem(ModArmorMaterial.XINSHOU, EquipmentSlotType.CHEST, (new Item.Properties()).tab(Armor)));
    public static final RegistryObject<Item> xinshouLeggings = ITEMS.register("xinshou_leggings", () -> new ArmorItem(ModArmorMaterial.XINSHOU, EquipmentSlotType.LEGS, (new Item.Properties()).tab(Armor)));
    public static final RegistryObject<Item> xinshouBoots = ITEMS.register("xinshou_boots", () -> new ArmorItem(ModArmorMaterial.XINSHOU, EquipmentSlotType.FEET, (new Item.Properties()).tab(Armor)));

    public static RegistryObject<Item> adjudication = ITEMS.register("adjudication", () -> new Adjudication());
    public static RegistryObject<Item> blastBullet = ITEMS.register("blast_bullet", () -> new BlastBullet());
    public static RegistryObject<Item> burningFeather = ITEMS.register("burning_feather", () -> new BurningFeather());
    public static RegistryObject<Item> charge = ITEMS.register("charge", () -> new Charge());
    public static RegistryObject<Item> devote = ITEMS.register("devote", () -> new Devote());
    public static RegistryObject<Item> enchanted = ITEMS.register("enchanted", () -> new Enchanted());
    public static RegistryObject<Item> explosionTrap = ITEMS.register("explosion_trap", () -> new ExplosionTrap());
    public static RegistryObject<Item> flameBomb = ITEMS.register("flame_bomb", () -> new FlameBomb());
    public static RegistryObject<Item> flames = ITEMS.register("flames", () -> new Flames());
    public static RegistryObject<Item> forcedOverload = ITEMS.register("forced_overload", () -> new ForcedOverload());
    public static RegistryObject<Item> forestPower = ITEMS.register("forest_power", () -> new ForestPower());
    public static RegistryObject<Item> fullConcentration = ITEMS.register("full_concentration", () -> new FullConcentration());
    public static RegistryObject<Item> impact = ITEMS.register("impact", () -> new Impact());
    public static RegistryObject<Item> inspire = ITEMS.register("inspire", () -> new Inspire());
    public static RegistryObject<Item> junglePhantom = ITEMS.register("jungle_phantom", () -> new JunglePhantom());
    public static RegistryObject<Item> jungleSpirit = ITEMS.register("jungle_spirit", () -> new JungleSpirit());
    public static RegistryObject<Item> lifeStream = ITEMS.register("life_stream", () -> new LifeStream());
    public static RegistryObject<Item> lightMarker = ITEMS.register("light_marker", () -> new LightMarker());
    public static RegistryObject<Item> pity = ITEMS.register("pity", () -> new Pity());
    public static RegistryObject<Item> rangeBall = ITEMS.register("range_ball", () -> new RangeBall());
    public static RegistryObject<Item> ringAttack = ITEMS.register("ring_attack", () -> new RingAttack());
    public static RegistryObject<Item> shanBall = ITEMS.register("shan_ball", () -> new ShanBall());
    public static RegistryObject<Item> shieldReaction = ITEMS.register("shield_reaction", () -> new ShieldReaction());
    public static RegistryObject<Item> starChop = ITEMS.register("star_chop", () -> new StarChop());
    public static RegistryObject<Item> starshards = ITEMS.register("star_shards", () -> new Starshards());
    public static RegistryObject<Item> thunderFalls = ITEMS.register("thunder_falls", () -> new ThunderFalls());
    public static RegistryObject<Item> thunderPossessed = ITEMS.register("thunder_possessed", () -> new ThunderPossessed());
    public static RegistryObject<Item> windSpell = ITEMS.register("wind_spell", () -> new WindSpell());
}
